home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / socks.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  12.2 KB  |  388 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from socket import *
  5. from socket import _fileobject
  6. import socket as _socket
  7. import struct
  8. import time
  9. _socket.setdefaulttimeout(20)
  10.  
  11. try:
  12.     _GLOBAL_DEFAULT_TIMEOUT = _socket._GLOBAL_DEFAULT_TIMEOUT
  13. except AttributeError:
  14.     pass
  15.  
  16. from errno import EALREADY, EINPROGRESS, EWOULDBLOCK
  17. import logging
  18. log = logging.getLogger('socks')
  19. PROXY_TYPE_SOCKS4 = 1
  20. PROXY_TYPE_SOCKS5 = 2
  21. PROXY_TYPE_HTTP = 3
  22. PROXY_TYPE_HTTPS = 4
  23. _defaultproxy = None
  24. _orgsocket = _socket.socket
  25.  
  26. class ProxyError(Exception):
  27.     
  28.     def __init__(self, value):
  29.         self.value = value
  30.  
  31.     
  32.     def __str__(self):
  33.         return repr(self.value)
  34.  
  35.     
  36.     def __repr__(self):
  37.         return '%s(%r)' % (type(self).__name__, repr(self.value))
  38.  
  39.  
  40.  
  41. class GeneralProxyError(ProxyError):
  42.     
  43.     def __init__(self, value):
  44.         self.value = value
  45.  
  46.     
  47.     def __str__(self):
  48.         return repr(self.value)
  49.  
  50.  
  51.  
  52. class Socks5AuthError(ProxyError):
  53.     
  54.     def __init__(self, value):
  55.         self.value = value
  56.  
  57.     
  58.     def __str__(self):
  59.         return repr(self.value)
  60.  
  61.  
  62.  
  63. class Socks5Error(ProxyError):
  64.     
  65.     def __init__(self, value):
  66.         self.value = value
  67.  
  68.     
  69.     def __str__(self):
  70.         return repr(self.value)
  71.  
  72.  
  73.  
  74. class Socks4Error(ProxyError):
  75.     
  76.     def __init__(self, value):
  77.         self.value = value
  78.  
  79.     
  80.     def __str__(self):
  81.         return repr(self.value)
  82.  
  83.  
  84.  
  85. class HTTPError(ProxyError):
  86.     
  87.     def __init__(self, value):
  88.         self.value = value
  89.  
  90.     
  91.     def __str__(self):
  92.         return repr(self.value)
  93.  
  94.  
  95. _generalerrors = ('success', 'invalid data', 'not connected', 'not available', 'bad proxy type', 'bad input')
  96. _socks5errors = ('succeeded', 'general SOCKS server failure', 'connection not allowed by ruleset', 'Network unreachable', 'Host unreachable', 'Connection refused', 'TTL expired', 'Command not supported', 'Address type not supported', 'Unknown error')
  97. _socks5autherrors = ('succeeded', 'authentication is required', 'all offered authentication methods were rejected', 'unknown username or invalid password', 'unknown error')
  98. _socks4errors = ('request granted', 'request rejected or failed', 'request rejected because SOCKS server cannot connect to identd on the client', 'request rejected because the client program and identd report different user-ids', 'unknown error')
  99.  
  100. def setdefaultproxy(proxytype = None, addr = None, port = None, rdns = True, username = None, password = None):
  101.     global _defaultproxy
  102.     _defaultproxy = (proxytype, addr, port, rdns, username, password)
  103.  
  104.  
  105. class socksocket(_orgsocket):
  106.     
  107.     def __init__(self, family = _socket.AF_INET, type = _socket.SOCK_STREAM, proto = 0, _sock = None):
  108.         _orgsocket.__init__(self, family, type, proto, _sock)
  109.         if _defaultproxy != None:
  110.             self._socksocket__proxy = _defaultproxy
  111.         else:
  112.             self._socksocket__proxy = (None, None, None, None, None, None)
  113.         self._socksocket__proxysockname = None
  114.         self._socksocket__proxypeername = None
  115.  
  116.     
  117.     def __recvall(self, bytes):
  118.         data = ''
  119.         while len(data) < bytes:
  120.             data = data + self.recv(bytes - len(data))
  121.             time.sleep(0.001)
  122.         return data
  123.  
  124.     
  125.     def setproxy(self, proxytype = None, addr = None, port = None, rdns = True, username = None, password = None):
  126.         self._socksocket__proxy = (proxytype, addr, port, rdns, username, password)
  127.  
  128.     
  129.     def __negotiatesocks5(self, destaddr, destport):
  130.         if self._socksocket__proxy[4] != None and self._socksocket__proxy[5] != None:
  131.             self.sendall('\x05\x02\x00\x02')
  132.         else:
  133.             self.sendall('\x05\x01\x00')
  134.         chosenauth = self._socksocket__recvall(2)
  135.         if chosenauth[0] != '\x05':
  136.             self.close()
  137.             raise GeneralProxyError((1, _generalerrors[1]))
  138.         
  139.         if chosenauth[1] == '\x00':
  140.             pass
  141.         elif chosenauth[1] == '\x02':
  142.             self.sendall('\x01' + chr(len(self._socksocket__proxy[4])) + self._socksocket__proxy[4] + chr(len(self._socksocket__proxy[5])) + self._socksocket__proxy[5])
  143.             authstat = self._socksocket__recvall(2)
  144.             if authstat[0] != '\x01':
  145.                 self.close()
  146.                 raise GeneralProxyError((1, _generalerrors[1]))
  147.             
  148.             if authstat[1] != '\x00':
  149.                 self.close()
  150.                 raise Socks5AuthError((3, _socks5autherrors[3]))
  151.             
  152.         else:
  153.             self.close()
  154.             if chosenauth[1] == '\xff':
  155.                 raise Socks5AuthError((2, _socks5autherrors[2]))
  156.             else:
  157.                 raise GeneralProxyError((1, _generalerrors[1]))
  158.         req = '\x05\x01\x00'
  159.         
  160.         try:
  161.             ipaddr = _socket.inet_aton(destaddr)
  162.             req = req + '\x01' + ipaddr
  163.         except _socket.error:
  164.             if self._socksocket__proxy[3] == True:
  165.                 ipaddr = None
  166.                 req = req + '\x03' + chr(len(destaddr)) + destaddr
  167.             else:
  168.                 ipaddr = _socket.inet_aton(_socket.gethostbyname(destaddr))
  169.                 req = req + '\x01' + ipaddr
  170.         except:
  171.             self._socksocket__proxy[3] == True
  172.  
  173.         req = req + struct.pack('>H', destport)
  174.         self.sendall(req)
  175.         resp = self._socksocket__recvall(4)
  176.         if resp[0] != '\x05':
  177.             self.close()
  178.             raise GeneralProxyError((1, _generalerrors[1]))
  179.         elif resp[1] != '\x00':
  180.             self.close()
  181.             if ord(resp[1]) <= 8:
  182.                 raise Socks5Error(ord(resp[1]), _generalerrors[ord(resp[1])])
  183.             else:
  184.                 raise Socks5Error(9, _generalerrors[9])
  185.         elif resp[3] == '\x01':
  186.             boundaddr = self._socksocket__recvall(4)
  187.         elif resp[3] == '\x03':
  188.             resp = resp + self.recv(1)
  189.             boundaddr = self._socksocket__recvall(resp[4])
  190.         else:
  191.             self.close()
  192.             raise GeneralProxyError((1, _generalerrors[1]))
  193.         boundport = struct.unpack('>H', self._socksocket__recvall(2))[0]
  194.         self._socksocket__proxysockname = (boundaddr, boundport)
  195.         if ipaddr != None:
  196.             self._socksocket__proxypeername = (_socket.inet_ntoa(ipaddr), destport)
  197.         else:
  198.             self._socksocket__proxypeername = (destaddr, destport)
  199.  
  200.     
  201.     def getproxysockname(self):
  202.         return self._socksocket__proxysockname
  203.  
  204.     
  205.     def getproxypeername(self):
  206.         return _orgsocket.getpeername(self)
  207.  
  208.     
  209.     def getpeername(self):
  210.         return self._socksocket__proxypeername
  211.  
  212.     
  213.     def __negotiatesocks4(self, destaddr, destport):
  214.         rmtrslv = False
  215.         
  216.         try:
  217.             ipaddr = _socket.inet_aton(destaddr)
  218.         except _socket.error:
  219.             if self._socksocket__proxy[3] == True:
  220.                 ipaddr = '\x00\x00\x00\x01'
  221.                 rmtrslv = True
  222.             else:
  223.                 ipaddr = _socket.inet_aton(_socket.gethostbyname(destaddr))
  224.         except:
  225.             self._socksocket__proxy[3] == True
  226.  
  227.         req = '\x04\x01' + struct.pack('>H', destport) + ipaddr
  228.         if self._socksocket__proxy[4] != None:
  229.             req = req + self._socksocket__proxy[4]
  230.         
  231.         req = req + '\x00'
  232.         if rmtrslv == True:
  233.             req = req + destaddr + '\x00'
  234.         
  235.         self.sendall(req)
  236.         resp = self._socksocket__recvall(8)
  237.         if resp[0] != '\x00':
  238.             self.close()
  239.             raise GeneralProxyError((1, _generalerrors[1]))
  240.         
  241.         if resp[1] != 'Z':
  242.             self.close()
  243.             if ord(resp[1]) in (91, 92, 93):
  244.                 self.close()
  245.                 raise Socks4Error((ord(resp[1]), _socks4errors[ord(resp[1]) - 90]))
  246.             else:
  247.                 raise Socks4Error((94, _socks4errors[4]))
  248.         
  249.         self._socksocket__proxysockname = (_socket.inet_ntoa(resp[4:]), struct.unpack('>H', resp[2:4])[0])
  250.         if rmtrslv != None:
  251.             self._socksocket__proxypeername = (_socket.inet_ntoa(ipaddr), destport)
  252.         else:
  253.             self._socksocket__proxypeername = (destaddr, destport)
  254.  
  255.     
  256.     def __negotiatehttps(self, destaddr, destport):
  257.         
  258.         try:
  259.             self._sock = _socket.ssl(self._sock)
  260.             self._socksocket__negotiatehttp(destaddr, destport)
  261.         except Exception:
  262.             e = None
  263.             raise _socket.error(e)
  264.  
  265.  
  266.     
  267.     def __negotiatehttp(self, destaddr, destport):
  268.         if self._socksocket__proxy[3] == False:
  269.             addr = _socket.gethostbyname(destaddr)
  270.         else:
  271.             addr = destaddr
  272.         self.sendall('CONNECT ' + addr + ':' + str(destport) + ' HTTP/1.1\r\n' + 'Host: ' + destaddr + '\r\n' + self._socksocket__httpauthstring() + '\r\n')
  273.         last = resp = self.recv(1)
  274.         while len(resp) < 32768 and last and resp.find('\r\n\r\n') == -1:
  275.             last = self.recv(1)
  276.             resp = resp + last
  277.         if not last or len(resp) >= 32768:
  278.             raise GeneralProxyError((1, _generalerrors[1], 'no response or response too large: %r' % resp))
  279.         
  280.         statusline = resp.splitlines()[0].split(' ', 2)
  281.         if statusline[0] not in ('HTTP/1.0', 'HTTP/1.1'):
  282.             self.close()
  283.             raise GeneralProxyError((1, _generalerrors[1], 'unknown statusline %r' % statusline))
  284.         
  285.         
  286.         try:
  287.             statuscode = int(statusline[1])
  288.         except ValueError:
  289.             self.close()
  290.             raise GeneralProxyError((1, _generalerrors[1], 'unknown status code in: %r' % statusline))
  291.  
  292.         if statuscode != 200:
  293.             self.close()
  294.             raise HTTPError((statuscode, statusline[2], 'non-200 status code: %r' % statuscode))
  295.         
  296.         self._socksocket__proxysockname = ('0.0.0.0', 0)
  297.         self._socksocket__proxypeername = (addr, destport)
  298.  
  299.     
  300.     def __httpauthstring(self):
  301.         (proxytype, addr, port, rdns, username, password) = self._socksocket__proxy
  302.         if all((username, password)):
  303.             raw = '%s:%s' % (username, password)
  304.             auth = 'Basic %s' % ''.join(raw.encode('base-64').strip().split())
  305.             return 'Proxy-Authorization: %s\r\n' % auth
  306.         else:
  307.             return ''
  308.  
  309.     
  310.     def connect(self, destpair):
  311.         return self._connect(destpair, _orgsocket.connect)
  312.  
  313.     
  314.     def _connect(self, destpair, connector):
  315.         E = None
  316.         return_val = None
  317.         
  318.         try:
  319.             destpair = self.check_destpair(destpair)
  320.             stuff = {
  321.                 PROXY_TYPE_SOCKS5: (1080, self._socksocket__negotiatesocks5),
  322.                 PROXY_TYPE_SOCKS4: (1080, self._socksocket__negotiatesocks4),
  323.                 PROXY_TYPE_HTTP: (8080, self._socksocket__negotiatehttp),
  324.                 PROXY_TYPE_HTTPS: (8080, self._socksocket__negotiatehttps) }
  325.             if self._socksocket__proxy[0] in stuff:
  326.                 (def_port, negotiate) = stuff[self._socksocket__proxy[0]]
  327.                 if self._socksocket__proxy[2] != None:
  328.                     portnum = self._socksocket__proxy[2]
  329.                 else:
  330.                     portnum = def_port
  331.                 
  332.                 try:
  333.                     return_val = connector(self, (self._socksocket__proxy[1], portnum))
  334.                 except _socket.error:
  335.                     e = None
  336.                     if e.args and e.args[0] not in (EINPROGRESS, EALREADY, EWOULDBLOCK):
  337.                         raise e
  338.                     
  339.                 except:
  340.                     e.args[0] not in (EINPROGRESS, EALREADY, EWOULDBLOCK)
  341.  
  342.                 log.debug('negotiating proxy for destpair %r: %r, password=%s', destpair, self._socksocket__proxy[:-1], bool(self._socksocket__proxy[-1]))
  343.                 negotiate(destpair[0], destpair[1])
  344.             elif self._socksocket__proxy[0] == None:
  345.                 log.debug('No proxy settings. connecting destpair %r', destpair)
  346.                 return_val = connector(self, (destpair[0], destpair[1]))
  347.             else:
  348.                 raise GeneralProxyError((4, _generalerrors[4]))
  349.         except _socket.error:
  350.             e = None
  351.             E = e
  352.             raise e
  353.         except Exception:
  354.             e = None
  355.             E = e
  356.             raise _socket.error(e)
  357.         finally:
  358.             if E is not None:
  359.                 if E.args and E.args[0] not in (EINPROGRESS, EALREADY, EWOULDBLOCK):
  360.                     log.debug('Error connecting to %r. self.__proxy is %r. Exception was %r', destpair, self._socksocket__proxy[:4], E)
  361.                 
  362.             
  363.  
  364.         return return_val
  365.  
  366.     
  367.     def check_destpair(self, destpair):
  368.         if isinstance(destpair[0], basestring):
  369.             
  370.             try:
  371.                 destpair = (str(destpair[0]), destpair[1])
  372.             except ValueError:
  373.                 raise _socket.gaierror("Couldn't coerce %r to str. Invalid hostname." % destpair[0])
  374.             except:
  375.                 None<EXCEPTION MATCH>ValueError
  376.             
  377.  
  378.         None<EXCEPTION MATCH>ValueError
  379.         if (list, tuple) in (list, tuple):
  380.             pass
  381.         elif (list, tuple) == False and len(destpair) < 2 and type(destpair[0]) != str or type(destpair[1]) != int:
  382.             raise GeneralProxyError((5, _generalerrors[5]))
  383.         
  384.         return destpair
  385.  
  386.  
  387. SocketType = socksocket
  388.